diff --git a/user_guide/general/alternative_php.html b/user_guide/general/alternative_php.html
index 61b9673..2f52b84 100644
--- a/user_guide/general/alternative_php.html
+++ b/user_guide/general/alternative_php.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Alternate PHP Syntax for View Files</title>
+<title>Alternate PHP Syntax for View Files : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/ancillary_classes.html b/user_guide/general/ancillary_classes.html
index 8ebab44..1a640e5 100644
--- a/user_guide/general/ancillary_classes.html
+++ b/user_guide/general/ancillary_classes.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Ancillary Classes</title>
+<title>Creating Ancillary Classes : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index 50d8fe9..7889b55 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Auto-loading Resources</title>
+<title>Auto-loading Resources : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/caching.html b/user_guide/general/caching.html
index b423326..cdb0260 100644
--- a/user_guide/general/caching.html
+++ b/user_guide/general/caching.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Web Page Caching</title>
+<title>Web Page Caching : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/controllers.html b/user_guide/general/controllers.html
index a05ee14..b561c8c 100644
--- a/user_guide/general/controllers.html
+++ b/user_guide/general/controllers.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Controllers</title>
+<title>Controllers : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/core_classes.html b/user_guide/general/core_classes.html
index 1e9cb1e..c8511fc 100644
--- a/user_guide/general/core_classes.html
+++ b/user_guide/general/core_classes.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Core System Classes</title>
+<title>Creating Core System Classes : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/creating_libraries.html b/user_guide/general/creating_libraries.html
index d32dda9..77f4bed 100644
--- a/user_guide/general/creating_libraries.html
+++ b/user_guide/general/creating_libraries.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Libraries</title>
+<title>Creating Libraries : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/credits.html b/user_guide/general/credits.html
index 7ad6b43..b4c53be 100644
--- a/user_guide/general/credits.html
+++ b/user_guide/general/credits.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Credits</title>
+<title>Credits : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 9c6a4e9..4c56bd3 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Error Handling</title>
+<title>Error Handling : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index 6d443b9..86ec05b 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Helper Functions</title>
+<title>Helper Functions : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/hooks.html b/user_guide/general/hooks.html
index 11acc04..f5e94c9 100644
--- a/user_guide/general/hooks.html
+++ b/user_guide/general/hooks.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Hooks</title>
+<title>Hooks : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/index.html b/user_guide/general/index.html
index 999498d..fe84cc6 100644
--- a/user_guide/general/index.html
+++ b/user_guide/general/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Getting Started With CodeIgniter</title>
+<title>Getting Started With CodeIgniter : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/libraries.html b/user_guide/general/libraries.html
index c4c7a5f..3ff254b 100644
--- a/user_guide/general/libraries.html
+++ b/user_guide/general/libraries.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Using CodeIgniter Libraries</title>
+<title>Using CodeIgniter Libraries : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/managing_apps.html b/user_guide/general/managing_apps.html
index 0bce79f..9b07413 100644
--- a/user_guide/general/managing_apps.html
+++ b/user_guide/general/managing_apps.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Managing your Applications</title>
+<title>Managing your Applications : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/models.html b/user_guide/general/models.html
index 9564e55..3ecdf5e 100644
--- a/user_guide/general/models.html
+++ b/user_guide/general/models.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Models</title>
+<title>Models : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index 449caae..41b1ea4 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Plugins</title>
+<title>Plugins : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index c506874..c09fc8b 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Profiling Your Application</title>
+<title>Profiling Your Application : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/quick_reference.html b/user_guide/general/quick_reference.html
index 5c76cc4..941f771 100644
--- a/user_guide/general/quick_reference.html
+++ b/user_guide/general/quick_reference.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Quick Reference Chart</title>
+<title>Quick Reference Chart : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/requirements.html b/user_guide/general/requirements.html
index 54a03c4..82d5122 100644
--- a/user_guide/general/requirements.html
+++ b/user_guide/general/requirements.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Server Requirements</title>
+<title>Server Requirements : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/routing.html b/user_guide/general/routing.html
index d225c11..80798cb 100644
--- a/user_guide/general/routing.html
+++ b/user_guide/general/routing.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : URI Routing</title>
+<title>URI Routing : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/scaffolding.html b/user_guide/general/scaffolding.html
index 3c1385e..65c1544 100644
--- a/user_guide/general/scaffolding.html
+++ b/user_guide/general/scaffolding.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Scaffolding</title>
+<title>Scaffolding : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/security.html b/user_guide/general/security.html
index 271fea8..7e27263 100644
--- a/user_guide/general/security.html
+++ b/user_guide/general/security.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Security</title>
+<title>Security : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index 823610f..96e9622 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter URLs</title>
+<title>CodeIgniter URLs : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index 41d6753..12a119a 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Views</title>
+<title>Views : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
